import time
from pages.excel_data_extraction import Excel_data_extraction
from config.settings import get_config
from base.base_page import BasePage

"""
封装功能函数

"""
class New_Token_Page(BasePage):
    def __init__(self, driver, device_type, logger=None):
        super().__init__(driver, device_type, logger=logger)  # 传递日志实例
        self.driver = driver
        self.config = get_config(device_type)  # 获取全局配置
        self.excel_processor = Excel_data_extraction(self.driver, device_type, logger=logger)

    ########################################  新建数据接口令牌控制  ########################################

    def new_token_page(self, token_name, token_time, token_time_customize=None):
        # 新建数据接口令牌
        # 1.进入基本可用配置界面--新建数据接口令牌控制页面
        self.enter_new_token_page()
        self.delete_token(token_name)
        # 2.点击新建按钮
        self.newly_built_token()
        # 3.输入令牌名称
        self.input_token_name(token_name)
        # 4.令牌码有效期：长期有效(不能点击后续研究)
        self.token_time(token_time, token_time_customize)
        # 5.点击保存
        self.save_new_token(token_name)

    def enter_new_token_page(self):
        # 进入基本可用配置界面--新建数据接口令牌控制页面
        status = self.find_element('first_level_menu_module', 'basic_available_configure_status')
        if "ivu-menu-opened" in status.get_attribute("class"):
            if self.quick_check_element('new_token_module', 'select_token_name'):
                pass
            else:
                self.click('second_level_menu_module', 'new_token')
                self.soft_assert_element_visible('new_token_module', 'select_token_name')
        else:
            self.click('first_level_menu_module', 'basic_available_configure')
            self.soft_assert_element_visible('second_level_menu_module', 'new_token')
            self.click('second_level_menu_module', 'new_token')
            self.soft_assert_element_visible('new_token_module', 'select_token_name')


    def newly_built_token(self):
        # 点击新建按钮
        self.click('common_elements', 'newly_built')
        self.soft_assert_element_visible('new_token_module', 'token_new_interface_title')

    def input_token_name(self, token_name):
        # 输入令牌名称
        self.input_text('new_token_module', 'token_name', token_name)
        self.soft_assert_input_value('new_token_module', 'token_name', token_name)

    def token_time(self, token_time, token_time_customize=None):
        if token_time == '长期有效':
            # 令牌长期有效
            self.click('new_token_module', 'token_time_long_term')
            token_time = self.find_element('new_token_module', 'token_time_long_term')
            if "ivu-radio-wrapper-checked" in token_time.get_attribute("class"):
                pass
                self.logger.info(f"令牌有效期：长期有效")
        elif token_time == '一周':
            # 令牌有限期：一周
            self.click('new_token_module', 'token_time_one_week')
            token_time = self.find_element('new_token_module', 'token_time_one_week')

        elif token_time == '一月':
            # 令牌有限期：一月
            self.click('new_token_module', 'token_time_one_month')
            token_time = self.find_element('new_token_module', 'token_time_one_month')

        elif token_time == '一年':
            # 令牌有限期：一年
            self.click('new_token_module', 'token_time_one_year')
            token_time = self.find_element('new_token_module', 'token_time_one_year')
        else:
            # 令牌有限期：自定义
            self.click('new_token_module', 'token_time_customize')
            token_time = self.find_element('new_token_module', 'token_time_customize')
            # 令牌输入自定义时间
            self.input_text('new_token_module', 'input_token_time_customize', token_time_customize)
        if "ivu-radio-wrapper-checked" in token_time.get_attribute("class"):
            pass
        else:
            self.logger.error('令牌有效期选择异常')


    def save_new_token(self, token_name):
        # 保存新建数据接口令牌
        self.click('new_token_module', 'new_token_save')
        self.find_element('common_elements', 'add_success')
        self.logger.info(f'数据接口令牌：{token_name} 保存成功')

    def select_new_token(self, token_name):
        # 筛选令牌名称
        self.click('new_token_module', 'select_token_name')
        # 使用 find_elements 获取所有选项
        options = self.find_elements('new_token_module', 'token_name_filtering')
        # 遍历匹配项
        for option in options:
            if option.text.strip() == token_name:  # 增加容错处理（如去除空格）
                option.click()
                break
        else:
            raise ValueError(f"未找到选项：'{token_name}'")
        # 验证结果
        self.soft_assert_input_value('new_token_module', 'select_token_name', token_name)

    def select_new_token_interface(self, interface_name):
        # 筛选令牌控制接口
        self.click('new_token_module', 'select_token_interface')
        # 使用 find_elements 获取所有选项
        options = self.find_elements('new_token_module', 'token_interface_filtering')
        # 遍历匹配项
        for option in options:
            if option.text.strip() == interface_name:  # 增加容错处理（如去除空格）
                option.click()
                break
        else:
            raise ValueError(f"未找到选项：'{interface_name}'")
        # 验证结果
        self.soft_assert_input_value('new_token_module', 'select_token_interface', interface_name)

    def get_token_code(self, interface_name):
        # 获取指定令牌的令牌码
        self.enter_new_token_page()
        current_page = 1
        while True:
            # 获取当前页所有接口名称元素
            name_elements = self.find_elements('new_token_module', 'token_interface_all')
            # 遍历当前页
            for row_index, element in enumerate(name_elements, 1):
                current_name = element.text.strip()
                if current_name == interface_name:
                    # 定位同行的令牌码元素
                    code_element = self.find_dynamic_element(
                        'new_token_module',
                        'token_code_all',
                        row_index
                    )
                    # 获取并存储令牌码
                    token_code = code_element.text.strip()
                    self.logger.info(f"找到接口 '{interface_name}' 的令牌码：{token_code}")
                    return token_code
            # 尝试翻页
            if not self._go_to_next_page():
                break
            current_page += 1 # 等待分页加载

    def export_token(self, token_name, token_interface, token_code, token_time, create_token_time):
        # 导出筛选后的令牌
        self.click('common_elements', 'export')
        excel_file = self.excel_processor.wait_for_new_excel(timeout=60)

        # 定义解析参数
        parse_params = {
            "sheet_name": "1-100",
            "start_row": 3,
            "headers": ["序号", "令牌名称", "此令牌控制数据接口", "令牌码", "令牌码有效期", "创建时间"],
            "max_rows": 10
        }

        # 解析Excel内容
        excel_data = self.excel_processor.parse_excel(excel_file, parse_params)

        # 只处理第一个数据条目
        for item in excel_data:
            # 记录完整数据
            self.logger.info("正在验证导出的令牌数据：")
            for key, value in item.items():
                self.logger.info(f"{key}: {value}")

            # 数据预处理
            token_interface = None if str(token_interface).strip() == '' else token_interface
            excel_values = {
                '令牌名称': str(item.get('令牌名称', '')).strip(),
                '接口控制': str(item.get('此令牌控制数据接口', '')).strip() or None,
                '令牌码': str(item.get('令牌码', '')).strip(),
                '有效期': str(item.get('令牌码有效期', '')).strip(),
                '创建时间': str(item.get('创建时间', '')).strip()
            }

            # 字段比较验证
            comparisons = [
                ('令牌名称', excel_values['令牌名称'], token_name),
                ('接口控制', excel_values['接口控制'], token_interface),
                ('令牌码', excel_values['令牌码'], token_code),
                ('有效期', excel_values['有效期'], token_time),
                ('创建时间', excel_values['创建时间'], create_token_time)
            ]

            # 执行所有字段比较
            all_match = True
            for field, actual, expected in comparisons:
                # 统一None处理
                actual = actual if actual != 'None' else None
                expected = str(expected).strip() if expected is not None else None
                if actual == expected:
                    self.logger.info(f"{field}匹配成功: {actual}")
                else:
                    all_match = False
                    self.logger.error(f"{field}匹配失败 | Excel值: {actual} | 期望值: {expected}")

            # 输出最终结果
            if all_match:
                self.logger.info("所有字段验证通过")
            else:
                self.logger.error("存在字段验证失败")

            # 无论是否匹配，执行一次后退出循环
            break

    def token_data(self, *fields):
        field_map = {
            "token_name": "first_token_name",
            "token_interface": "first_token_interface",
            "token_code": "first_token_code",
            "token_time": "first_token_time",
            "create_token_time": "first_create_token_time"
        }
        # 如果没有传参，默认返回全部字段（保持原顺序）
        if not fields:
            fields = ("token_name", "token_interface", "token_code", "token_time", "create_token_time")

        # 根据映射关系获取值
        result = []
        for field in fields:
            mapped_field = field_map.get(field)
            if not mapped_field:  # 处理无效参数名
                raise ValueError(f"无效参数名: {field}")
            result.append(self.get_element_text("new_token_module", mapped_field))

        # 如果只传单个参数，直接返回标量值（可选）
        return tuple(result) if len(result) > 1 else result[0] if result else None

    def delete_token(self, token_name):
        """
        支持分页查找并删除对象
        :param token_name: 要删除的对象名称
        """
        if self.quick_check_element('common_elements', 'no_data'):
            pass
        else:
            current_page = 1
            while True:
                # 获取当前页所有对象名称
                name_elements = self.find_elements('new_token_module', 'token_name_all')
                # 遍历当前页
                for row_index, element in enumerate(name_elements, 1):
                    if element.text.strip() == token_name:
                        self._delete_current_row(row_index)
                        self.logger.info(f"成功删除第{current_page}页的'{token_name}'")
                        return
                # 尝试翻页
                if not self._go_to_next_page():
                    break
                current_page += 1 # 等待分页加载

    def _delete_current_row(self, row_index):
        """执行单行删除操作"""
        delete_btn = self.find_dynamic_element(
            'new_token_module',
            'delete_token_all',
            row_index
        )
        token_interface = self.find_dynamic_element(
            'new_token_module',
            'token_interface_all_dynamics',
            row_index
        )
        token_interface = token_interface.text.strip()
        if token_interface == '':
            # 点击删除按钮
            delete_btn.click()
            self.click('common_elements', 'confirm_button')
            self.find_element('common_elements', 'delete_success')
        else:
            pass